Labview.c

Go to the documentation of this file.

#include "LIN_UART.h"
#include "Labview.h"
#include "utils.h"
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */
static const uint8_t cu8StartOfFrame[] = "[MS00[MP00[TI00[TS00[TT00";
static const uint8_t cu8StartOfFrameD[] = "[DA0[DS0";
static const uint8_t cu8StartOfFrameT[] = "[RS[RR[RE";
static const uint8_t cu8StartOfFrameE[] = "[DD";
static const uint8_t cu8EndofFrame = ']';
const uint8_t cau8FakeTime[] = 
{
  '1', '2', '3', '4'
};
void (* const pvfnMixNMatch[])(uint8_t* pu8Data, 
                                      uint8_t u8Length, 
                                      uint8_t u8Type) = 
    {
      &vfnLVMixAndMatch, &vfnLVMixAndMatchParallel
    };

/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
uint8_t gau8LabViewMessage[LABVIEW_COMPOSITE_MESSAGE_SIZE];
uint8_t gau8LabViewRxCmd[LABVIEW_CMD_MSG_SIZE];
/*
 ******************************************************************************
 * vfnLVMixAndMatch
 ******************************************************************************
 */
void vfnLVMixAndMatch(uint8_t* pu8Data, uint8_t u8Length, uint8_t u8Type)
{
  uint8_t u8Status;
  uint8_t u8LengthInHexASCII[2u];
  
  /* Start transmission of start of frame while other things are figured out */
  u8Status = u8fnUARTWrite(LABVIEW_SCI, \
                             &(cu8StartOfFrame[SIZE_OF_SOF * u8Type]), \
                             SIZE_OF_SOF);
  if(CLEAR == u8Status)
  {
    /* Transform the length value into an ASCII reading - still in hex */
    vfnHexToASCII(&u8Length, (uint8_t*)u8LengthInHexASCII, sizeof(u8Length));
    
    /* Once it's done, send data. */
    (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)&u8LengthInHexASCII, \
                        N_ELEMENTS(u8LengthInHexASCII));
    (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)pu8Data, u8Length);
    /* End of Frame */
    (void)u8fnUARTWrite(LABVIEW_SCI, &cu8EndofFrame, sizeof(cu8EndofFrame));
  }
  else
  {
    /* Nothing, we can't transmit, but it's not critical */
  }
  return;
}
/*
 ******************************************************************************
 * vfnLVMixAndMatchParallel
 ******************************************************************************
 */
void vfnLVMixAndMatchParallel(uint8_t* pu8Data, uint8_t u8Length, \
                              uint8_t u8Type)
{
  uint8_t u8SizeOfTx;
  
  /* Since this routine uses a shared global variable to construct its    */
  /* messages, we must make sure there is no on-going transmission before */
  /* constructing it, or else we might corrupt the ongoing transmission.  */
  if(CLEAR == gau8LINUARTWordsTx[LABVIEW_SCI])
  {
    /* We'll place everything within gau8LabViewMessage and start a tx    */
    /* afterwards.                                                        */
    u8SizeOfTx = SIZE_OF_SOF;
    vfnCopyArray((uint8_t*)&(cu8StartOfFrame[SIZE_OF_SOF * u8Type]), \
                 gau8LabViewMessage, (uint16_t)u8SizeOfTx);

    /* Transform the length value into an ASCII reading - still in hex */
    vfnHexToASCII((uint8_t*)&u8Length, \
                  (uint8_t*)&(gau8LabViewMessage[u8SizeOfTx]), \
                  sizeof(u8Length));
    u8SizeOfTx += (sizeof(u8Length) * 2u);
    
    /* Once it's done, copy data. */
    vfnCopyArray((uint8_t*)pu8Data, (uint8_t*)&(gau8LabViewMessage[u8SizeOfTx]), \
                 u8Length);
    u8SizeOfTx += u8Length;
    /* End of Frame */
    vfnCopyArray((uint8_t*)&cu8EndofFrame, \
                 (uint8_t*)&(gau8LabViewMessage[u8SizeOfTx]),\
                 sizeof(cu8EndofFrame));
    u8SizeOfTx += sizeof(cu8EndofFrame);
    
    /* Start SM for UART Send. If already on, this instruction will be */
    /* ignored.                                                        */
    (void)u8fnLINUARTSend(LABVIEW_SCI, (const uint8_t*)&gau8LabViewMessage, \
                          u8SizeOfTx);
  }
  else
  {
    /* No status byte so far. */
  }
    
  
  return;
}
/*
 ******************************************************************************
 * u8fnLabViewSendMS
 ******************************************************************************
 */
uint8_t  u8fnLabViewSendMSorMP(uint8_t *pu8Data, uint8_t u8Length, \
                               uint8_t u8Mode, uint8_t u8LabViewMsgType)         
{
  /*
  MESSAGE FRAME

  ·     « [«            START
  ·      «Type»         2 characters : Identify type of data being sent
                                    « MS»       Follow up message displayed in GUI 
                                « MP »  Pop up message displayed as a pop up with user to be required to press OK
  ·     « NB »  4 characters: Number of characters sent
  ·     C1 characters 1,
  ·     C2 characters 2,
  ·     C3 characters 3,
  ·     C4 characters 4,
  ·     C5 characters 5,
  ·     C6 characters 6,
  ·     …
  ·     « ] »           END
  
  */
  (*pvfnMixNMatch[u8Mode])(pu8Data, u8Length, u8LabViewMsgType);

  return(CLEAR);
}
/*
 ******************************************************************************
 * vfnDisplaySCIData
 ******************************************************************************
 */
void vfnDisplaySCIData(uint8_t u8Type, uint8_t u8BitSizeOfSample, \
                       uint8_t u8NOfStreams, uint16_t u16NOfSamples, \
                       uint8_t* pu8Data)
{
  /* Declare local variables */
  uint8_t  au8LengthInHexASCII[2u];
  uint8_t  au8SamplesInHexASCII[4u];
  uint8_t  au8DataInHexASCII[2u];
  uint32_t u32TotalSize;
  uint8_t  u8Status;
  //uint8_t  au8FakeTime[4u] = "1234";
  
  /* Init local variables */
  u8Status      = CLEAR;
  
  /* u16NoOfSamples determines how many samples there is per stream.     */
  /* u8NoOfStreams identifies the number of sources available            */
  /* u8BitSizeSample is used as an index for either 8, 16, 24, or 32 bit */
  /* data per sample per stream                                         */
  u32TotalSize  = (uint32_t)(u16NOfSamples * u8NOfStreams * \
                                     u8BitSizeOfSample);
  
  /* Decide between DA or DS in the init of the message */
  switch(u8Type)
  {
    case(LV_DA_MSG):
    {
      (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)\
                                       (&(cu8StartOfFrameD[CLEAR])),\
                          SIZE_OF_SOF_FOR_D);
      break;
    }
    case(LV_DS_MSG):
    {
      (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)\
                                     (&(cu8StartOfFrameD[SIZE_OF_SOF_FOR_D])),\
                          SIZE_OF_SOF_FOR_D);
       break;
    }
    default:
    {
      /* We have an error */
      u8Status = TRUE;
      break;
    }
  };
  
  /* Only continue if we can */
  if(CLEAR == u8Status)
  {
    /* Send the number of streams */
    vfnHexToASCII(&u8NOfStreams, (uint8_t*)&au8LengthInHexASCII, 1u);
    (void)u8fnUARTWrite(LABVIEW_SCI, \
                        (const uint8_t*)&(au8LengthInHexASCII[1u]), (uint8_t)1u);
    
    /* Send the number of samples */
    vfnHexToASCII((uint8_t*)&u16NOfSamples, au8SamplesInHexASCII, \
                  sizeof(u16NOfSamples));
    (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)&au8SamplesInHexASCII, \
                        sizeof(au8SamplesInHexASCII));
    
    /* Send Fake Time */
    (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)&cau8FakeTime, \
                        sizeof(cau8FakeTime));
    /* Send data. All of it */
    for(; u32TotalSize > CLEAR; u32TotalSize--)
    {
       vfnHexToASCII(pu8Data, au8DataInHexASCII, 1u);
       (void)u8fnUARTWrite(LABVIEW_SCI, (const uint8_t*)au8DataInHexASCII, \
                        sizeof(au8DataInHexASCII));
       pu8Data++;
       
    }
    
    /* Send EOF */
    (void)u8fnUARTWrite(LABVIEW_SCI, &cu8EndofFrame, sizeof(cu8EndofFrame));
    
    
  }
  else
  {
    /* Exit */
  }
  
  return;
}
/*
 ******************************************************************************
 * vfnDisplaySCIDataParallel
 ******************************************************************************
 */
void vfnDisplaySCIDataParallel(uint8_t u8Type, uint8_t u8BitSizeOfSample, \
                       uint8_t u8NOfStreams, uint16_t u16NOfSamples, \
                       uint8_t* pu8Data)
{
  /* Declare local variables */
  uint8_t  au8LengthInHexASCII[2u];
  uint32_t u32TotalSize;
  uint8_t  u8Status;
  uint8_t  u8TxSize;
  uint8_t  u8SOFIndex;
  
  /* Init local variables */
  u8Status = CLEAR;
  u8TxSize = CLEAR;
  u8SOFIndex = CLEAR;
  
  /* Only continue if we don't have an ongoing transmission.  */
  if(CLEAR == gau8LINUARTWordsTx[LABVIEW_SCI])
  {
    /* u16NoOfSamples determines how many samples there is per stream.     */
    /* u8NoOfStreams identifies the number of sources available            */
    /* u8BitSizeSample is used as an index for either 8, 16, 24, or 32 bit */
    /* data per sample per stream                                         */
    u32TotalSize  = (uint32_t)(u16NOfSamples * u8NOfStreams * \
        u8BitSizeOfSample);
    
    /* Decide between DA or DS in the init of the message */
    if(LV_DA_MSG == u8Type)
    {
      u8SOFIndex = CLEAR;
    }
    else if(LV_DS_MSG == u8Type)
    {
      u8SOFIndex = SIZE_OF_SOF_FOR_D;
    }
    else
    {
      u8Status = TRUE;
    }
        
    /* Only continue if we can */
    if(CLEAR == u8Status)
    {
      /* Copy the correct array to the right location */
      vfnCopyArray((uint8_t*)&(cu8StartOfFrameD[u8SOFIndex]), \
                   (uint8_t*)&gau8LabViewMessage, SIZE_OF_SOF_FOR_D);
      u8TxSize += SIZE_OF_SOF_FOR_D;
      
      /* Send the number of streams */
      vfnHexToASCII(&u8NOfStreams, (uint8_t*)&au8LengthInHexASCII, \
                    sizeof(u8NOfStreams));
      vfnCopyArray((uint8_t*)&(au8LengthInHexASCII[1u]), \
                   (uint8_t*)&(gau8LabViewMessage[u8TxSize]), 1u);
      u8TxSize++;
      
      /* Send the number of samples */
      vfnHexToASCII((uint8_t*)&u16NOfSamples, \
                    (uint8_t*)&(gau8LabViewMessage[u8TxSize]), \
                    sizeof(u16NOfSamples));
      u8TxSize += (2u * sizeof(u16NOfSamples));

      
      /* Send Fake Time */
      vfnCopyArray((uint8_t*)&cau8FakeTime, \
                   (uint8_t*)&(gau8LabViewMessage[u8TxSize]), sizeof(cau8FakeTime));
      u8TxSize += sizeof(cau8FakeTime);

      /* Send data. All of it */
      vfnHexToASCII(pu8Data, (uint8_t*)&(gau8LabViewMessage[u8TxSize]), \
                    (uint16_t)u32TotalSize);
      u8TxSize += ((uint8_t)u32TotalSize * 2u);
      
      
      /* End of Frame */
      vfnCopyArray((uint8_t*)&cu8EndofFrame, \
                   (uint8_t*)&(gau8LabViewMessage[u8TxSize]),\
                   sizeof(cu8EndofFrame));
      u8TxSize += sizeof(cu8EndofFrame);
          
      /* Start SM for UART Send. If already on, this instruction will be */
      /* ignored.                                                        */
      (void)u8fnLINUARTSend(LABVIEW_SCI, (const uint8_t*)&gau8LabViewMessage, \
                            u8TxSize);
    }
    else
    {
      /* Exit */
    }
  }
  else
  {
    /* Not good */
    u8Status = 1u;
  }
  return;
}
/*
 ******************************************************************************
 * vfnLVTriggerEvent
 ******************************************************************************
 */
void vfnLVTriggerEvent(void)
{
  /* Send Event Frame */
  (void)u8fnUARTWrite(LABVIEW_SCI, (uint8_t*)cu8StartOfFrameE, \
                           sizeof(cu8StartOfFrameE));
  (void)u8fnUARTWrite(LABVIEW_SCI, &cu8EndofFrame, sizeof(cu8EndofFrame));

  return;
}
/*
 ******************************************************************************
 * vfnDisplaySCIRegistersInTable
 ******************************************************************************
 */
void vfnDisplaySCIRegistersInTable(uint8_t u8TableType, \
                                   uint16_t u16InitAddress, \
                                   uint16_t u16NOfData, \
                                   uint8_t* pu8RegTable)      
{
  /* Declare local variables */
  uint8_t u8Status;
  uint8_t au8InitAddressASCII[4u];
  uint8_t au8NOfDataASCII[4u];
  uint8_t au8NextByteASCII[2u];
  
  /* Init local variables */
  u8Status = CLEAR;
  
  /* Decide which kind of message we're sending */
  if(LV_RS_MSG == u8TableType)
  {
    (void)u8fnLINUARTSend(LABVIEW_SCI, (const uint8_t*)\
                                       (&(cu8StartOfFrameT[CLEAR])),\
                        SIZE_OF_SOF_FOR_T);
  }
  else if(LV_RR_MSG == u8TableType)
  {
    (void)u8fnLINUARTSend(LABVIEW_SCI, (const uint8_t*)\
                                     (&(cu8StartOfFrameT[SIZE_OF_SOF_FOR_T])),\
                        SIZE_OF_SOF_FOR_T);
  }
  else if(LV_RE_MSG == u8TableType)
  {
    (void)u8fnLINUARTSend(LABVIEW_SCI, (const uint8_t*)\
                                (&(cu8StartOfFrameT[SIZE_OF_SOF_FOR_T * 2u])),\
                        SIZE_OF_SOF_FOR_T);
  }
  else
  {
    u8Status = TRUE;
  }
  
  /* Continue if we can */
  if(CLEAR == u8Status)
  {
    /* Format asks for a 4-character Address - perform this while the start  */
    /* of frame is being sent                                                */
    vfnHexToASCII((uint8_t*)&u16InitAddress, (uint8_t*)au8InitAddressASCII, \
                  sizeof(u16InitAddress));
    
    /* Since we're optimizing time, we will also need to send u16NOfData in  */
    /* ASCII. Transform it to ASCII now                                      */
    vfnHexToASCII((uint8_t*)&u16NOfData, (uint8_t*)au8NOfDataASCII, \
                  sizeof(u16NOfData));
    
    /* Start transmitting when ready */
    u8Status = u8fnWaitForUARTTxBufferToEmpty(LABVIEW_SCI, SCI_TIME_OUT);
    
    if(CLEAR == u8Status)
    {
      /* Send Address */
      (void)u8fnUARTWrite(LABVIEW_SCI, (uint8_t*)au8InitAddressASCII, \
                          sizeof(au8InitAddressASCII));
      /* Send Number of data to send */
      (void)u8fnUARTWrite(LABVIEW_SCI, (uint8_t*)au8NOfDataASCII, \
                          sizeof(au8NOfDataASCII));
      for(;u16NOfData > CLEAR; u16NOfData--)
      {
        /* Convert next data to Hex while we have an ongoing transmission */
        vfnHexToASCII(pu8RegTable, (uint8_t*)au8NextByteASCII, 1u);
        
        /* Increment pointer */
        pu8RegTable++;
        
        u8Status = u8fnUARTWrite(LABVIEW_SCI, (uint8_t*)au8NextByteASCII, \
                                 sizeof(au8NextByteASCII));
        
      } /* End FOR */
      
      /* Send EOF */
      u8Status = u8fnWaitForUARTTxBufferToEmpty(LABVIEW_SCI, SCI_TIME_OUT);
      if(CLEAR == u8Status)
      {
        (void)u8fnUARTWrite(LABVIEW_SCI, &cu8EndofFrame, sizeof(cu8EndofFrame));
      }
      else
      {
        /* Exit */
      } /* end else */
    } /* End if */
    else
    {
      /* Exit */
    }
  } /* End if */
  else
  {
    /* Exit */
  }
  
  return;
}
/*
 ******************************************************************************
 * u8fnLVConfigRxCmd
 ******************************************************************************
 */
uint8_t u8fnLVConfigRxCmd(void)
{
  return(u8fnLINUARTReceive(LABVIEW_SCI, gau8LabViewRxCmd, CLEAR));
}
/*
 ******************************************************************************
 * u8fnLVReceiveCmd
 ******************************************************************************
 */
uint8_t u8fnLVReceiveCmd(void)
{
  uint8_t u8Status;
  
  /* Get all the data */
  u8Status = u8fnLINUARTGetDataNoIsr(LABVIEW_SCI);
  /* Reset our pointer, etc. */
  if(UART_NO_DATA_RX == u8Status)
  {
    /* Nothing */
  }
  else
  {
    u8Status = u8fnLVConfigRxCmd();
  }
  return(u8Status);
}
/*
 ******************************************************************************
 * vfnLVEnable
 ******************************************************************************
 */
void vfnLVEnable(uint8_t u8Enable)
{
  vfnEnableLINTxISR(LABVIEW_SCI, u8Enable);
 
  return;
}
/*
 ******************************************************************************
 * u8fnLVWaitForTxPort
 ******************************************************************************
 */
uint8_t u8fnLVWaitForTxPort(void)
{
  return(u8fnWaitForUARTTxBufferToEmpty(LABVIEW_SCI, SCI_TIME_OUT));
}

/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */